home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 2003 June / macformat-130.iso / mac / Reviewed⁄Demos / Spearhead Demo / demota / pak1.pk3 / global / alarmer.scr < prev    next >
Encoding:
Text File  |  2002-10-21  |  11.6 KB  |  540 lines
  1. //    Alarm system used in m4l3 and m6l2a. Created by Mackey McCandlish and calibrated with Steve Fukuda.
  2. //
  3. //    Before level waittill prespawn: "exec global/alarmer.scr"
  4. //    Anybody with targetname "enemy" will try to ring the alarm.
  5. //    Alarms are animate_equipment_alarmswitch with targetname "alarm" and they point away from the surface they're placed against.
  6. //    The alarm spawners are AI placed in the level with targetname "alarmspawner".
  7. //    The Alarm triggers are "trigger_use"s with setthread "alarm_player_reset". They encompass the actual alarm.
  8. //    You can set level.alarm_always_on to 1 and the alarm will come back on after 14-20 seconds.
  9. //
  10. //
  11.  
  12.  
  13. main:
  14.  
  15.     level.alarm_always_on = 0
  16.     level.alarm_always_on_base = 14
  17.     level.alarm_always_on_random = 7
  18.     level.alarm_time = 0
  19.     level.alarm_time_base = 14
  20.     level.alarm_time_random = 5
  21.  
  22.     for (local.i=1;local.i<$alarm.size+1;local.i++)
  23.         $alarm[local.i] notsolid
  24.  
  25. level waittill prespawn
  26.         
  27.     while ($alarmspawner)
  28.     {
  29.             local.ent = waitthread global/spawner.scr::spawner_create $alarmspawner[1]
  30.             local.ent.targetname = "alarmspawned"
  31.     }
  32.  
  33.  
  34. level waittill spawn
  35.  
  36.     
  37.     thread alarmgenner
  38.     $player.alarmoff = level.time + 1
  39.     thread alarmer
  40.     
  41.     /*
  42.         $endgate_left time 1
  43.         $endgate_right time 1
  44.  
  45.         $endgate_right rotateyup 80
  46.         $endgate_right move
  47.         $endgate_left rotateydown 100
  48.         $endgate_left waitmove
  49.         $endgate_left connect_paths
  50.         $endgate_right connect_paths
  51.     */
  52. end
  53.  
  54.  
  55.  
  56.  
  57. doalarm:
  58.     level.alarmers++
  59.     println "doing alarm"
  60.     local.range = 5000
  61.     local.alarm = -1
  62.     println ("Enemy " + (vector_length (self.origin - $player.origin)) + " distance away is doing alarm and is in thinkstate " + self.thinkstate)
  63.     for (local.i=1;local.i<$alarm.size+1;local.i++)
  64.     {
  65.         local.temprange = vector_length (self.origin - $alarm[local.i].origin)
  66.         if ((local.temprange < local.range) && (vector_length ($player.origin - $alarm[local.i].origin) > local.temprange))
  67.         {
  68.             local.range = local.temprange
  69.             local.alarm = local.i
  70.         }
  71.     }
  72.  
  73.     if (local.alarm != -1)
  74.     {
  75.         local.break = 0
  76.         local.timer = level.time + 12
  77.     
  78.         thread de-alarmer
  79.  
  80.         local.org = angles_toforward ($alarm[local.alarm].angles)
  81. //        local.org = ((local.org * 30) + ($alarm[local.alarm].origin)) + ( 0 0 -25 )
  82.         local.org = ((local.org * 35) + ($alarm[local.alarm].origin)) + ( 0 0 -30 )
  83.         local.ent = spawn script_origin
  84.         local.ent.origin = local.org
  85.         local.ent droptofloor
  86.         local.org = local.ent.origin
  87.         local.ent delete
  88.  
  89.  
  90.         wait (randomfloat(2.3))
  91.         self exec global/disable_ai.scr
  92. //        self type_attack "alarm"
  93. //        local.ent = spawn script_origin
  94. //        local.ent.origin = local.org
  95. //        self alarmnode local.ent
  96. //        self alarmthread "alarmreg"
  97. //        println "should be running for alarm"
  98. //        waitframe
  99.  
  100.         self.movedoneradius = 15
  101.         while ((isalive self) && (local.break == 0) && (level.time < local.timer)) 
  102.         {
  103.             self runto local.org
  104.             self waittill movedone
  105.  
  106.             if (level.alarm_on == 0)
  107.             {
  108.                 if (vector_length (self.origin - $alarm[local.alarm].origin) < 90)
  109.                 {
  110.                     self.turndoneerror = 10
  111.                     self turnto $alarm[local.alarm]
  112.                     self waittill turndone
  113.                     self anim alarm_switchon
  114.                     self playsound alarm_switch
  115.  
  116.                     local.break = 1
  117.                     
  118.                     wait 0.2
  119.                     for (local.i=1;local.i<$alarm.size+1;local.i++)
  120.                            $alarm[local.i] anim turnon
  121.  
  122.                     wait 0.5
  123.                     level.alarm_on = 1
  124.                 }
  125.             }
  126.             else
  127.             local.break = 1
  128.  
  129.             wait 1
  130.         }
  131.     }
  132.     else
  133.         level.alarmers--
  134.  
  135.     if (isalive self)
  136.         self exec global/enable_ai.scr
  137.  
  138. end
  139.  
  140. de-alarmer:
  141.     wait 12
  142.     level.alarmers--
  143. end
  144.  
  145. alarmreg:
  146. end
  147.  
  148.  
  149. /*
  150. alarmreg:
  151. //            self runto local.org // $alarm[local.alarm]
  152.             self waittill movedone
  153.             if (parm.movefail == 1)
  154.             {
  155.                 local.break = 1
  156.                 level.alarmers--
  157.                 self.targetname = "enemy_noalarm"
  158.                 local.oldalarm = $alarm[local.alarm]
  159.                 local.oldalarm.targetname = "alarm_noalarm"
  160.  
  161.                 wait 5
  162.                 self runto $player
  163.                 self.targetname = "enemy"
  164.                 local.oldalarm.targetname = "alarm"
  165.                 end
  166.             }
  167.             else
  168.  
  169.             wait 1
  170.         }
  171.         
  172.     }
  173.  
  174.     self exec global/enable_ai.scr
  175.  
  176.  
  177. end
  178.  
  179. end
  180.  
  181. */
  182.  
  183. alarm_player_reset:
  184.     if (level.time > $player.alarmoff)
  185.     {
  186.         $player.alarmoff = level.time + 1
  187.  
  188.         if (level.alarm_on == 1)
  189.         {
  190.             level.alarm_on = 0
  191.             
  192.             for (local.i=1;local.i<$alarm.size+1;local.i++)
  193.                    $alarm[local.i] anim turnoff
  194.  
  195.             self playsound alarm_switch
  196.             if (level.alarm_time - level.time < 5)
  197.                 level.alarm_time = level.time + (level.alarm_time_base + randomint(alarm_time_random))
  198.  
  199.             wait 0.5
  200.  
  201. //            for (local.i=1;local.i<$alarm.size+1;local.i++)
  202. //                   $alarm[local.i] stoploopsound
  203.  
  204.             level.alarm_sound stoploopsound
  205.  
  206.             if (level.alarm_always_on == 1)
  207.                 wait (level.alarm_always_on_base + randomint(level.alarm_always_on_random))
  208.  
  209.             if (level.alarm_always_on == 1)
  210.             {
  211.                 if (level.alarm_on == 0)
  212.                 {
  213.                     level.alarm_on = 1
  214.                             
  215.                     for (local.i=1;local.i<$alarm.size+1;local.i++)
  216.                            $alarm[local.i] anim turnon
  217.  
  218.                     self playsound alarm_switch
  219.  
  220.                     wait 0.5
  221.  
  222. //                    for (local.i=1;local.i<$alarm.size+1;local.i++)
  223. //                        $alarm[local.i] loopsound alarmbell
  224.  
  225.                 }
  226.             }
  227.         }
  228.         else
  229.         {
  230.             level.alarm_on = 1
  231.             
  232.             for (local.i=1;local.i<$alarm.size+1;local.i++)
  233.                    $alarm[local.i] anim turnon
  234.  
  235.             self playsound alarm_switch
  236.  
  237.             wait 0.5
  238.  
  239. //            for (local.i=1;local.i<$alarm.size+1;local.i++)
  240. //                $alarm[local.i] loopsound alarmbell
  241.  
  242.         }
  243.     }
  244.  
  245. //    local.alarmbell thread global/loopsound.scr::main alarmbell     // Ring the alarm bell
  246.  
  247. end
  248.  
  249. turn_alarm_on:
  250.     if (level.alarm_on == 0)
  251.     {
  252.         level.alarm_on = 1
  253.                 
  254.         for (local.i=1;local.i<$alarm.size+1;local.i++)
  255.                $alarm[local.i] anim turnon
  256.  
  257.         self playsound alarm_switch
  258.  
  259.         wait 0.5
  260.  
  261. //        for (local.i=1;local.i<$alarm.size+1;local.i++)
  262. //            $alarm[local.i] loopsound alarmbell
  263.     }
  264. end
  265.  
  266. alarmsounder:
  267.     
  268.     level.alarm_sound = spawn script_model
  269. //    level.alarm_sound thread playersoundorg
  270.     level.alarm_sound model "fx/dummy.tik"
  271.     level.alarm_sound notsolid
  272.  
  273.     while (1)
  274.     {
  275.         if (level.alarm_on == 1)
  276.         {
  277.             local.range = 1400
  278.     
  279.             for (local.i=1;local.i<$alarm.size+1;local.i++)
  280.             {
  281.                 local.newrange = vector_length ( $player.origin - $alarm[local.i].origin)
  282.                 if (local.newrange < local.range)
  283.                 {
  284. //                    $alarm[local.i] loopsound alarmbell
  285.                     local.range = local.newrange
  286.                 }
  287. //                waitframe
  288.             }
  289.  
  290. /*
  291.             1400    50        1400
  292.             0.2        1.5        0.2
  293.             1.7        0.2        1.7
  294.  
  295. 1.5
  296. */
  297.             local.vol = (1.5 / 1350) * (local.range)
  298.             local.vol = 1.5 - local.vol
  299.             if (local.vol < 0.2)
  300.                 local.vol = 0.2
  301.             else
  302.             if (local.vol > 1.5)
  303.                 local.vol = 1.5
  304. //                println ("range is " + local.range + " and vol is " + local.vol)
  305.  
  306.             level.alarm_sound loopsound alarmbell local.vol "levelwide"
  307.  
  308.         }
  309.         waitframe
  310.     }
  311.  
  312. end
  313.  
  314. alarmgenner:
  315.  
  316.     if (level.alarm_nosound == NIL)
  317.         thread alarmsounder
  318.     
  319.     local.timer = level.time
  320.     while (isalive $player)
  321.     {
  322.         if (level.alarm_on == 1)
  323.         {
  324.             if (level.time > local.timer)
  325.             {
  326.                 local.key = getboundkey1 "+use"
  327.                 iprintlnbold_noloc (loc_convert_string "Approach alarms and press the USE key ( ") local.key (loc_convert_string " ) to toggle them off or on.")
  328.                 local.timer = level.time + 12
  329.             }
  330.  
  331.             while (level.totalspawnies < 2)
  332.             {
  333.                 waitthread create_alarmguy
  334.                 wait randomint (3)
  335.             }
  336.         }
  337.         else
  338.             local.timer = level.time + 45
  339.  
  340.         wait 1
  341.     }
  342.  
  343. end
  344.  
  345. create_alarmguy:
  346.  
  347.     local.range = 5000
  348.     local.entnum = -1
  349.     local.num = 0
  350. //    local.spawner = -1
  351.     for (local.i=1;local.i<$alarmspawned.size+1;local.i++)
  352.     {
  353.         if !($player canseenoents ($alarmspawned[local.i].origin + (0 0 50)))
  354.         {
  355.             local.num++
  356.             local.spawner[local.num] = $alarmspawned[local.i]
  357.             println ("prepped a spawner at " + local.spawner[local.num].origin + " with num " + local.num)
  358.         }
  359.         wait 0.1
  360.     }
  361.  
  362.     if (local.spawner == NIL)
  363.         end
  364.  
  365.     local.lastnum = -1
  366.  
  367.     for (local.i=1;local.i<local.num+1;local.i++)
  368.     {
  369.         local.temprange = vector_length ($player.origin - local.spawner[local.i].origin)
  370.         println ("checking local spawner " + local.i + " and local num is " + local.num + " at range " + local.temprange)
  371.         if (local.temprange < local.range)
  372.         {
  373.             local.range = local.temprange
  374.             local.lastnum = local.entnum
  375.             local.entnum = local.i
  376.         }
  377.     }
  378.  
  379.     if (local.lastnum != -1)
  380.         local.entnum = local.lastnum
  381.  
  382.     if (local.entnum != -1)
  383.     {
  384.         local.ent = waitthread global/spawner.scr::spawner_activate local.spawner[local.entnum]
  385.         local.ent.targetname = "alarm_spawned_guy"
  386.  
  387.         local.ent thread spawnerthink
  388.     }
  389.     else
  390.     {
  391.         println "-------------------"
  392.         println local.range
  393.         println local.lastnum
  394.         println local.entnum
  395.         println "-------------------"
  396.     }
  397. end
  398.  
  399. runcheck:
  400.     if (level.runcheck)
  401.         level.runcheck delete
  402.  
  403.     level.runcheck = local
  404.     while (isalive self)
  405.     {
  406.         if (getcvar(debug) == "1")
  407.         println ("A spawned guy is at " + self.origin + " with thinkstate " + self.thinkstate)
  408.         wait 1
  409.     }
  410.  
  411. end
  412.  
  413. spawnerthink:
  414.     if (game.skill == "hard")
  415.         if (randomint(100) > 60)
  416.             self item items/item_25_healthbox.tik 25
  417.  
  418.     self ammo_grenade (randomint(4) + 1)
  419.     self mindist 128
  420.     self leash 8000
  421.     self maxdist 400
  422.     self fixedleash 0
  423.     self.movedoneradius = 450
  424.     wait randomfloat(3)
  425.     level.totalspawnies++
  426.     thread baddeath
  427.     self.nosurprise = 1
  428.     local.origin = self.origin
  429.  
  430.     self thread level.script::alarmer
  431.     self forceactivate
  432.     wait 1
  433.     if (self.thinkstate == "idle")
  434.     {
  435.         println ("spawned guy is running to the player from " + self.origin)
  436.         self thread runcheck
  437.         self runto $player
  438.         self waittill movedone
  439.         self attackplayer
  440. //        println ("movefail is " + parm.movefail)
  441.  
  442.         if ((parm.movefail == 1) && !(self canseenoents $player) && (vector_length (self.origin - local.origin) < 100))
  443.             self damage $world 15000 $world (0 0 0) (0 0 0) (0 0 0) 0 9 0 0
  444.     }
  445.  
  446.     while (isalive self)
  447.     {
  448.         println ("spawned guy is running to the player from " + self.origin)
  449.         self runto $player
  450.         self waittill movedone
  451.         self attackplayer
  452.         wait 2
  453.     }
  454. end
  455.  
  456. baddeath:
  457.     self waittill death
  458.     println "I die!"
  459.     level.totalspawnies--
  460. end
  461.  
  462. debugprint:
  463.     while (1)
  464.     {
  465.         println ("alarmers = " + level.alarmers + " baddies " + level.totalspawnies)
  466.         wait 1
  467.     }
  468.  
  469. end
  470.  
  471.  
  472. alarmer:
  473.     level.alarmers = 0
  474.     level.totalspawnies = 0
  475.     level.alarm_on = 0
  476.     if (getcvar(skill) == "0")
  477.         local.alarmcount = 0
  478.     else
  479.         local.alarmcount = 1
  480.  
  481.     if (getcvar(debug) == "1")
  482.     thread debugprint
  483.     
  484.     while (1)
  485.     {
  486.         while ((level.alarmers > local.alarmcount) || (level.alarm_on == 1) || (level.time < level.alarm_time))
  487.             wait 1
  488.  
  489.         wait randomfloat(2)
  490.         local.ent = -1
  491.         local.lastent = -1
  492.         local.range = 1500
  493.         for (local.i=1;local.i<$enemy.size+1;local.i++)
  494.         {
  495.             if ((isalive $enemy[local.i]) && ($enemy[local.i].thinkstate != "idle")) //  ($enemy[local.i] cansee $player)) 
  496.             {
  497.                 local.newrange = vector_length ($enemy[local.i].origin - $player.origin)
  498.                 if (local.newrange < local.range)
  499.                 {
  500.                     local.range = local.newrange
  501.                     local.ent = local.i
  502. /*
  503.                     if (local.lastent == -1)
  504.                     {
  505.                         local.ent = local.lastent
  506.                         local.lastent = local.i
  507.                     }
  508.                     else
  509.                     {
  510.                         local.lastent = local.i
  511.                         local.ent = local.i
  512.                     }
  513. */
  514.                 }
  515.             }
  516. //            else
  517. //            println ("thinkstate is " + $enemy[local.i].thinkstate)
  518.         }
  519.         
  520.  
  521.         if (local.ent != -1)
  522.         {
  523.             if (game.skill == "hard")
  524.                 $enemy[local.ent] thread doalarm
  525.             else
  526.             if ($enemy[local.ent] canseenoents $player)
  527.                 $enemy[local.ent] thread doalarm
  528.         }
  529.  
  530.         /*
  531.         else
  532.         if (local.lastent != -1)
  533.         if (level.enemy[local.lastent] cansee $player)
  534.             level.enemy[local.lastent] thread bridgeblownow (randomint(3))
  535.         */
  536.  
  537.         wait 2
  538.     }
  539. end
  540.